home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / random.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  557 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from warnings import warn as _warn
  5. from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
  6. from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
  7. from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  8. from os import urandom as _urandom
  9. from binascii import hexlify as _hexlify
  10. __all__ = [
  11.     'Random',
  12.     'seed',
  13.     'random',
  14.     'uniform',
  15.     'randint',
  16.     'choice',
  17.     'sample',
  18.     'randrange',
  19.     'shuffle',
  20.     'normalvariate',
  21.     'lognormvariate',
  22.     'expovariate',
  23.     'vonmisesvariate',
  24.     'gammavariate',
  25.     'gauss',
  26.     'betavariate',
  27.     'paretovariate',
  28.     'weibullvariate',
  29.     'getstate',
  30.     'setstate',
  31.     'jumpahead',
  32.     'WichmannHill',
  33.     'getrandbits',
  34.     'SystemRandom']
  35. NV_MAGICCONST = 4 * _exp(-0.5) / _sqrt(2)
  36. TWOPI = 2 * _pi
  37. LOG4 = _log(4)
  38. SG_MAGICCONST = 1 + _log(4.5)
  39. BPF = 53
  40. RECIP_BPF = 2 ** (-BPF)
  41. import _random
  42.  
  43. class Random(_random.Random):
  44.     VERSION = 2
  45.     
  46.     def __init__(self, x = None):
  47.         self.seed(x)
  48.         self.gauss_next = None
  49.  
  50.     
  51.     def seed(self, a = None):
  52.         if a is None:
  53.             
  54.             try:
  55.                 a = long(_hexlify(_urandom(16)), 16)
  56.             except NotImplementedError:
  57.                 import time as time
  58.                 a = long(time.time() * 256)
  59.             except:
  60.                 None<EXCEPTION MATCH>NotImplementedError
  61.             
  62.  
  63.         None<EXCEPTION MATCH>NotImplementedError
  64.         super(Random, self).seed(a)
  65.         self.gauss_next = None
  66.  
  67.     
  68.     def getstate(self):
  69.         return (self.VERSION, super(Random, self).getstate(), self.gauss_next)
  70.  
  71.     
  72.     def setstate(self, state):
  73.         version = state[0]
  74.         if version == 2:
  75.             (version, internalstate, self.gauss_next) = state
  76.             super(Random, self).setstate(internalstate)
  77.         else:
  78.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  79.  
  80.     
  81.     def __getstate__(self):
  82.         return self.getstate()
  83.  
  84.     
  85.     def __setstate__(self, state):
  86.         self.setstate(state)
  87.  
  88.     
  89.     def __reduce__(self):
  90.         return (self.__class__, (), self.getstate())
  91.  
  92.     
  93.     def randrange(self, start, stop = None, step = 1, int = int, default = None, maxwidth = 0x1L << BPF):
  94.         istart = int(start)
  95.         if istart != start:
  96.             raise ValueError, 'non-integer arg 1 for randrange()'
  97.         
  98.         if stop is default:
  99.             if istart > 0:
  100.                 if istart >= maxwidth:
  101.                     return self._randbelow(istart)
  102.                 
  103.                 return int(self.random() * istart)
  104.             
  105.             raise ValueError, 'empty range for randrange()'
  106.         
  107.         istop = int(stop)
  108.         if istop != stop:
  109.             raise ValueError, 'non-integer stop for randrange()'
  110.         
  111.         width = istop - istart
  112.         if step == 1 and width > 0:
  113.             if width >= maxwidth:
  114.                 return int(istart + self._randbelow(width))
  115.             
  116.             return int(istart + int(self.random() * width))
  117.         
  118.         if step == 1:
  119.             raise ValueError, 'empty range for randrange() (%d,%d, %d)' % (istart, istop, width)
  120.         
  121.         istep = int(step)
  122.         if istep != step:
  123.             raise ValueError, 'non-integer step for randrange()'
  124.         
  125.         if istep > 0:
  126.             n = (width + istep - 1) // istep
  127.         elif istep < 0:
  128.             n = (width + istep + 1) // istep
  129.         else:
  130.             raise ValueError, 'zero step for randrange()'
  131.         if n <= 0:
  132.             raise ValueError, 'empty range for randrange()'
  133.         
  134.         if n >= maxwidth:
  135.             return istart + istep * self._randbelow(n)
  136.         
  137.         return istart + istep * int(self.random() * n)
  138.  
  139.     
  140.     def randint(self, a, b):
  141.         return self.randrange(a, b + 1)
  142.  
  143.     
  144.     def _randbelow(self, n, _log = _log, int = int, _maxwidth = 0x1L << BPF, _Method = _MethodType, _BuiltinMethod = _BuiltinMethodType):
  145.         
  146.         try:
  147.             getrandbits = self.getrandbits
  148.         except AttributeError:
  149.             pass
  150.  
  151.         if type(self.random) is _BuiltinMethod or type(getrandbits) is _Method:
  152.             k = int(1.00001 + _log(n - 1, 2))
  153.             r = getrandbits(k)
  154.             while r >= n:
  155.                 r = getrandbits(k)
  156.             return r
  157.         
  158.         if n >= _maxwidth:
  159.             _warn('Underlying random() generator does not supply \nenough bits to choose from a population range this large')
  160.         
  161.         return int(self.random() * n)
  162.  
  163.     
  164.     def choice(self, seq):
  165.         return seq[int(self.random() * len(seq))]
  166.  
  167.     
  168.     def shuffle(self, x, random = None, int = int):
  169.         if random is None:
  170.             random = self.random
  171.         
  172.         for i in reversed(xrange(1, len(x))):
  173.             j = int(random() * (i + 1))
  174.             x[i] = x[j]
  175.             x[j] = x[i]
  176.         
  177.  
  178.     
  179.     def sample(self, population, k):
  180.         n = len(population)
  181.         if k <= k:
  182.             pass
  183.         elif not k <= n:
  184.             raise ValueError, 'sample larger than population'
  185.         
  186.         random = self.random
  187.         _int = int
  188.         result = [
  189.             None] * k
  190.         setsize = 21
  191.         if k > 5:
  192.             setsize += 4 ** _ceil(_log(k * 3, 4))
  193.         
  194.         if n <= setsize or hasattr(population, 'keys'):
  195.             pool = list(population)
  196.             for i in xrange(k):
  197.                 j = _int(random() * (n - i))
  198.                 result[i] = pool[j]
  199.                 pool[j] = pool[n - i - 1]
  200.             
  201.         else:
  202.             
  203.             try:
  204.                 selected = set()
  205.                 selected_add = selected.add
  206.                 for i in xrange(k):
  207.                     j = _int(random() * n)
  208.                     while j in selected:
  209.                         j = _int(random() * n)
  210.                     selected_add(j)
  211.                     result[i] = population[j]
  212.             except (TypeError, KeyError):
  213.                 if isinstance(population, list):
  214.                     raise 
  215.                 
  216.                 return self.sample(tuple(population), k)
  217.  
  218.         return result
  219.  
  220.     
  221.     def uniform(self, a, b):
  222.         return a + (b - a) * self.random()
  223.  
  224.     
  225.     def normalvariate(self, mu, sigma):
  226.         random = self.random
  227.         while None:
  228.             u1 = random()
  229.             u2 = 1 - random()
  230.             z = NV_MAGICCONST * (u1 - 0.5) / u2
  231.             zz = z * z / 4
  232.             if zz <= -_log(u2):
  233.                 break
  234.                 continue
  235.             continue
  236.             return mu + z * sigma
  237.  
  238.     
  239.     def lognormvariate(self, mu, sigma):
  240.         return _exp(self.normalvariate(mu, sigma))
  241.  
  242.     
  243.     def expovariate(self, lambd):
  244.         random = self.random
  245.         u = random()
  246.         while u <= 1e-07:
  247.             u = random()
  248.         return -_log(u) / lambd
  249.  
  250.     
  251.     def vonmisesvariate(self, mu, kappa):
  252.         random = self.random
  253.         if kappa <= 1e-06:
  254.             return TWOPI * random()
  255.         
  256.         a = 1 + _sqrt(1 + 4 * kappa * kappa)
  257.         b = (a - _sqrt(2 * a)) / 2 * kappa
  258.         r = (1 + b * b) / 2 * b
  259.         while None:
  260.             u1 = random()
  261.             z = _cos(_pi * u1)
  262.             f = (1 + r * z) / (r + z)
  263.             c = kappa * (r - f)
  264.             u2 = random()
  265.             if u2 < c * (2 - c) or u2 <= c * _exp(1 - c):
  266.                 break
  267.                 continue
  268.             continue
  269.             u3 = random()
  270.             if u3 > 0.5:
  271.                 theta = mu % TWOPI + _acos(f)
  272.             else:
  273.                 theta = mu % TWOPI - _acos(f)
  274.         return theta
  275.  
  276.     
  277.     def gammavariate(self, alpha, beta):
  278.         if alpha <= 0 or beta <= 0:
  279.             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
  280.         
  281.         random = self.random
  282.         if alpha > 1:
  283.             ainv = _sqrt(2 * alpha - 1)
  284.             bbb = alpha - LOG4
  285.             ccc = alpha + ainv
  286.             while None:
  287.                 u1 = random()
  288.                 if u1 < u1:
  289.                     pass
  290.                 elif not u1 < 1:
  291.                     continue
  292.                 
  293.                 u2 = 1 - random()
  294.                 v = _log(u1 / (1 - u1)) / ainv
  295.                 x = alpha * _exp(v)
  296.                 z = u1 * u1 * u2
  297.                 r = bbb + ccc * v - x
  298.                 if r + SG_MAGICCONST - 4.5 * z >= 0 or r >= _log(z):
  299.                     return x * beta
  300.                     continue
  301.                 continue
  302.         alpha > 1
  303.         if alpha == 1:
  304.             u = random()
  305.             while u <= 1e-07:
  306.                 u = random()
  307.             return -_log(u) * beta
  308.         else:
  309.             while None:
  310.                 u = random()
  311.                 b = (_e + alpha) / _e
  312.                 p = b * u
  313.                 if p <= 1:
  314.                     x = p ** (1 / alpha)
  315.                 else:
  316.                     x = -_log((b - p) / alpha)
  317.                 u1 = random()
  318.                 if p > 1:
  319.                     if u1 <= x ** (alpha - 1):
  320.                         break
  321.                     
  322.                 if u1 <= _exp(-x):
  323.                     break
  324.                     continue
  325.                 continue
  326.                 return x * beta
  327.                 return None
  328.  
  329.     
  330.     def gauss(self, mu, sigma):
  331.         random = self.random
  332.         z = self.gauss_next
  333.         self.gauss_next = None
  334.         if z is None:
  335.             x2pi = random() * TWOPI
  336.             g2rad = _sqrt(-2 * _log(1 - random()))
  337.             z = _cos(x2pi) * g2rad
  338.             self.gauss_next = _sin(x2pi) * g2rad
  339.         
  340.         return mu + z * sigma
  341.  
  342.     
  343.     def betavariate(self, alpha, beta):
  344.         y = self.gammavariate(alpha, 1)
  345.         if y == 0:
  346.             return 0
  347.         else:
  348.             return y / (y + self.gammavariate(beta, 1))
  349.  
  350.     
  351.     def paretovariate(self, alpha):
  352.         u = 1 - self.random()
  353.         return 1 / pow(u, 1 / alpha)
  354.  
  355.     
  356.     def weibullvariate(self, alpha, beta):
  357.         u = 1 - self.random()
  358.         return alpha * pow(-_log(u), 1 / beta)
  359.  
  360.  
  361.  
  362. class WichmannHill(Random):
  363.     VERSION = 1
  364.     
  365.     def seed(self, a = None):
  366.         if a is None:
  367.             
  368.             try:
  369.                 a = long(_hexlify(_urandom(16)), 16)
  370.             except NotImplementedError:
  371.                 import time
  372.                 a = long(time.time() * 256)
  373.             except:
  374.                 None<EXCEPTION MATCH>NotImplementedError
  375.             
  376.  
  377.         None<EXCEPTION MATCH>NotImplementedError
  378.         if not isinstance(a, (int, long)):
  379.             a = hash(a)
  380.         
  381.         (a, x) = divmod(a, 30268)
  382.         (a, y) = divmod(a, 30306)
  383.         (a, z) = divmod(a, 30322)
  384.         self._seed = (int(x) + 1, int(y) + 1, int(z) + 1)
  385.         self.gauss_next = None
  386.  
  387.     
  388.     def random(self):
  389.         (x, y, z) = self._seed
  390.         x = 171 * x % 30269
  391.         y = 172 * y % 30307
  392.         z = 170 * z % 30323
  393.         self._seed = (x, y, z)
  394.         return (x / 30269 + y / 30307 + z / 30323) % 1
  395.  
  396.     
  397.     def getstate(self):
  398.         return (self.VERSION, self._seed, self.gauss_next)
  399.  
  400.     
  401.     def setstate(self, state):
  402.         version = state[0]
  403.         if version == 1:
  404.             (version, self._seed, self.gauss_next) = state
  405.         else:
  406.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  407.  
  408.     
  409.     def jumpahead(self, n):
  410.         if not n >= 0:
  411.             raise ValueError('n must be >= 0')
  412.         
  413.         (x, y, z) = self._seed
  414.         x = int(x * pow(171, n, 30269)) % 30269
  415.         y = int(y * pow(172, n, 30307)) % 30307
  416.         z = int(z * pow(170, n, 30323)) % 30323
  417.         self._seed = (x, y, z)
  418.  
  419.     
  420.     def __whseed(self, x = 0, y = 0, z = 0):
  421.         if type(y) == type(y) and type(z) == type(z):
  422.             pass
  423.         elif not type(z) == int:
  424.             raise TypeError('seeds must be integers')
  425.         
  426.         if x == x and y == y:
  427.             pass
  428.         elif y == z:
  429.             import time
  430.             t = long(time.time() * 256)
  431.             t = int(t & 16777215 ^ t >> 24)
  432.             (t, x) = divmod(t, 256)
  433.             (t, y) = divmod(t, 256)
  434.             (t, z) = divmod(t, 256)
  435.         
  436.         if not z:
  437.             pass
  438.         self._seed = (None, 1 if not x else 1, 1)
  439.         self.gauss_next = None
  440.  
  441.     
  442.     def whseed(self, a = None):
  443.         if a is None:
  444.             self._WichmannHill__whseed()
  445.             return None
  446.         
  447.         a = hash(a)
  448.         (a, x) = divmod(a, 256)
  449.         (a, y) = divmod(a, 256)
  450.         (a, z) = divmod(a, 256)
  451.         if not (x + a) % 256:
  452.             pass
  453.         x = 1
  454.         if not (y + a) % 256:
  455.             pass
  456.         y = 1
  457.         if not (z + a) % 256:
  458.             pass
  459.         z = 1
  460.         self._WichmannHill__whseed(x, y, z)
  461.  
  462.  
  463.  
  464. class SystemRandom(Random):
  465.     
  466.     def random(self):
  467.         return (long(_hexlify(_urandom(7)), 16) >> 3) * RECIP_BPF
  468.  
  469.     
  470.     def getrandbits(self, k):
  471.         if k <= 0:
  472.             raise ValueError('number of bits must be greater than zero')
  473.         
  474.         if k != int(k):
  475.             raise TypeError('number of bits should be an integer')
  476.         
  477.         bytes = (k + 7) // 8
  478.         x = long(_hexlify(_urandom(bytes)), 16)
  479.         return x >> bytes * 8 - k
  480.  
  481.     
  482.     def _stub(self, *args, **kwds):
  483.         pass
  484.  
  485.     seed = jumpahead = _stub
  486.     
  487.     def _notimplemented(self, *args, **kwds):
  488.         raise NotImplementedError('System entropy source does not have state.')
  489.  
  490.     getstate = setstate = _notimplemented
  491.  
  492.  
  493. def _test_generator(n, func, args):
  494.     import time
  495.     print n, 'times', func.__name__
  496.     total = 0
  497.     sqsum = 0
  498.     smallest = 1e+10
  499.     largest = -1e+10
  500.     t0 = time.time()
  501.     for i in range(n):
  502.         x = func(*args)
  503.         total += x
  504.         sqsum = sqsum + x * x
  505.         smallest = min(x, smallest)
  506.         largest = max(x, largest)
  507.     
  508.     t1 = time.time()
  509.     print round(t1 - t0, 3), 'sec,',
  510.     avg = total / n
  511.     stddev = _sqrt(sqsum / n - avg * avg)
  512.     print 'avg %g, stddev %g, min %g, max %g' % (avg, stddev, smallest, largest)
  513.  
  514.  
  515. def _test(N = 2000):
  516.     _test_generator(N, random, ())
  517.     _test_generator(N, normalvariate, (0, 1))
  518.     _test_generator(N, lognormvariate, (0, 1))
  519.     _test_generator(N, vonmisesvariate, (0, 1))
  520.     _test_generator(N, gammavariate, (0.01, 1))
  521.     _test_generator(N, gammavariate, (0.1, 1))
  522.     _test_generator(N, gammavariate, (0.1, 2))
  523.     _test_generator(N, gammavariate, (0.5, 1))
  524.     _test_generator(N, gammavariate, (0.9, 1))
  525.     _test_generator(N, gammavariate, (1, 1))
  526.     _test_generator(N, gammavariate, (2, 1))
  527.     _test_generator(N, gammavariate, (20, 1))
  528.     _test_generator(N, gammavariate, (200, 1))
  529.     _test_generator(N, gauss, (0, 1))
  530.     _test_generator(N, betavariate, (3, 3))
  531.  
  532. _inst = Random()
  533. seed = _inst.seed
  534. random = _inst.random
  535. uniform = _inst.uniform
  536. randint = _inst.randint
  537. choice = _inst.choice
  538. randrange = _inst.randrange
  539. sample = _inst.sample
  540. shuffle = _inst.shuffle
  541. normalvariate = _inst.normalvariate
  542. lognormvariate = _inst.lognormvariate
  543. expovariate = _inst.expovariate
  544. vonmisesvariate = _inst.vonmisesvariate
  545. gammavariate = _inst.gammavariate
  546. gauss = _inst.gauss
  547. betavariate = _inst.betavariate
  548. paretovariate = _inst.paretovariate
  549. weibullvariate = _inst.weibullvariate
  550. getstate = _inst.getstate
  551. setstate = _inst.setstate
  552. jumpahead = _inst.jumpahead
  553. getrandbits = _inst.getrandbits
  554. if __name__ == '__main__':
  555.     _test()
  556.  
  557.